jdk-sandbox: comparison hotspot/src/share/vm/prims/jvm.cpp

equal deleted inserted replaced

-:7d079e0eedef
+:ab48109f7d1b
 arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));
 arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));
 assert(s->is_oop(), "JVM_ArrayCopy: src not an oop");
 assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop");
 // Do copy
-Klass::cast(s->klass())->copy_array(s, src_pos, d, dst_pos, length, thread);
+s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread);
 JVM_END
 static void set_property(Handle props, const char* key, const char* value, TRAPS) {
 JavaValue r(T_OBJECT);
 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))
 JVMWrapper("JVM_GetCallerClass");
 Klass* k = thread->security_get_caller_class(depth);
-return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
+return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror());
 JVM_END
 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
 JVMWrapper("JVM_FindPrimitiveClass");
 }
 if (TraceClassResolution) {
 trace_class_resolution(k);
 }
-return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
+return (jclass) JNIHandles::make_local(env, k->java_mirror());
 JVM_END
 JVM_ENTRY(jclass, JVM_FindClassFromClassLoader(JNIEnv* env, const char* name,
 jboolean init, jobject loader,
 jboolean throwError))
 ? (Klass*)NULL
 : java_lang_Class::as_Klass(from_class_oop);
 oop class_loader = NULL;
 oop protection_domain = NULL;
 if (from_class != NULL) {
-class_loader = Klass::cast(from_class)->class_loader();
+class_loader = from_class->class_loader();
-protection_domain = Klass::cast(from_class)->protection_domain();
+protection_domain = from_class->protection_domain();
 }
 Handle h_loader(THREAD, class_loader);
 Handle h_prot  (THREAD, protection_domain);
 jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
 h_prot, true, thread);
 if (TraceClassResolution && result != NULL) {
 // this function is generally only used for class loading during verification.
 ResourceMark rm;
 oop from_mirror = JNIHandles::resolve_non_null(from);
 Klass* from_class = java_lang_Class::as_Klass(from_mirror);
-const char * from_name = Klass::cast(from_class)->external_name();
+const char * from_name = from_class->external_name();
 oop mirror = JNIHandles::resolve_non_null(result);
 Klass* to_class = java_lang_Class::as_Klass(mirror);
-const char * to = Klass::cast(to_class)->external_name();
+const char * to = to_class->external_name();
 tty->print("RESOLVE %s %s (verification)\n", from_name, to);
 }
 return result;
 JVM_END
 if (TraceClassResolution && k != NULL) {
 trace_class_resolution(k);
 }
-return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
+return (jclass) JNIHandles::make_local(env, k->java_mirror());
 }
 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
 JVMWrapper2("JVM_DefineClass %s", name);
 h_loader,
 Handle(),
 CHECK_NULL);
 return (k == NULL) ? NULL :
-(jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
+(jclass) JNIHandles::make_local(env, k->java_mirror());
 JVM_END
 // Reflection support //////////////////////////////////////////////////////////////////////////////
 name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls)));
 } else {
 // Consider caching interned string in Klass
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
 assert(k->is_klass(), "just checking");
-name = Klass::cast(k)->external_name();
+name = k->external_name();
 }
 oop result = StringTable::intern((char*) name, CHECK_NULL);
 return (jstring) JNIHandles::make_local(env, result);
 JVM_END
 // Fill in result
 if (klass->oop_is_instance()) {
 // Regular instance klass, fill in all local interfaces
 for (int index = 0; index < size; index++) {
 Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index);
-result->obj_at_put(index, Klass::cast(k)->java_mirror());
+result->obj_at_put(index, k->java_mirror());
 }
 } else {
 // All arrays implement java.lang.Cloneable and java.io.Serializable
-result->obj_at_put(0, Klass::cast(SystemDictionary::Cloneable_klass())->java_mirror());
+result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror());
-result->obj_at_put(1, Klass::cast(SystemDictionary::Serializable_klass())->java_mirror());
+result->obj_at_put(1, SystemDictionary::Serializable_klass()->java_mirror());
 }
 return (jobjectArray) JNIHandles::make_local(env, result());
 JVM_END
 JVMWrapper("JVM_GetClassLoader");
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 return NULL;
 }
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
-oop loader = Klass::cast(k)->class_loader();
+oop loader = k->class_loader();
 return JNIHandles::make_local(env, loader);
 JVM_END
 JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
 oop mirror = JNIHandles::resolve_non_null(cls);
 if (java_lang_Class::is_primitive(mirror)) {
 return JNI_FALSE;
 }
 Klass* k = java_lang_Class::as_Klass(mirror);
-jboolean result = Klass::cast(k)->is_interface();
+jboolean result = k->is_interface();
-assert(!result || Klass::cast(k)->oop_is_instance(),
+assert(!result || k->oop_is_instance(),
 "all interfaces are instance types");
 // The compiler intrinsic for isInterface tests the
 // Klass::_access_flags bits in the same way.
 return result;
 JVM_END
 return NULL;
 }
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 objArrayOop signers = NULL;
-if (Klass::cast(k)->oop_is_instance()) {
+if (k->oop_is_instance()) {
 signers = InstanceKlass::cast(k)->signers();
 }
 // If there are no signers set in the class, or if the class
 // is an array, return NULL.
 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 // 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.
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
-if (Klass::cast(k)->oop_is_instance()) {
+if (k->oop_is_instance()) {
 InstanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers)));
 }
 }
 JVM_END
 // Primitive types does not have a protection domain.
 return NULL;
 }
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
-return (jobject) JNIHandles::make_local(env, Klass::cast(k)->protection_domain());
+return (jobject) JNIHandles::make_local(env, k->protection_domain());
 JVM_END
 // Obsolete since 1.2 (Class.setProtectionDomain removed), although
 // still defined in core libraries as of 1.5.
 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
 // Call is ignored for primitive types
 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()) {
+if (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);
 }
 }
 // Check that action object understands "Object run()"
 Handle object (THREAD, JNIHandles::resolve(action));
 // get run() method
-Method* m_oop = Klass::cast(object->klass())->uncached_lookup_method(
+Method* m_oop = 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() || !m()->is_public() || m()->is_static()) {
 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method");
 JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_IsArrayClass");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
-return (k != NULL) && Klass::cast(k)->oop_is_array() ? true : false;
+return (k != NULL) && k->oop_is_array() ? true : false;
 JVM_END
 JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_IsPrimitiveClass");
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 // Primitive type
 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
 }
-Klass* k = Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)));
+Klass* k = 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();
 JVM_END
 JvmtiVMObjectAllocEventCollector oam;
 // ofClass is a reference to a java_lang_Class object. The mirror object
 // of an InstanceKlass
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
-! Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {
+! 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_Klass(JNIHandles::resolve_non_null(ofClass)));
 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
 {
 // 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_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {
+! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_instance()) {
 return NULL;
 }
 bool inner_is_member = false;
 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)
-return (jclass) JNIHandles::make_local(env, Klass::cast(outer_klass)->java_mirror());
+return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror());
 }
 JVM_END
 // should be in InstanceKlass.cpp, but is here for historical reasons
 Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k,
 JvmtiVMObjectAllocEventCollector oam;
 ResourceMark rm(THREAD);
 // Return null for arrays and primatives
 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
-if (Klass::cast(k)->oop_is_instance()) {
+if (k->oop_is_instance()) {
 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());
 }
 JVMWrapper("JVM_GetClassAnnotations");
 ResourceMark rm(THREAD);
 // Return null for arrays and primitives
 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
-if (Klass::cast(k)->oop_is_instance()) {
+if (k->oop_is_instance()) {
 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
 return (jbyteArray) JNIHandles::make_local(env, a);
 }
 }
 return NULL;
 JVMWrapper("JVM_GetClassDeclaredFields");
 JvmtiVMObjectAllocEventCollector oam;
 // Exclude primitive types and array types
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
-Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) {
+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);
 }
 JVMWrapper("JVM_GetClassDeclaredMethods");
 JvmtiVMObjectAllocEventCollector oam;
 // Exclude primitive types and array types
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
-|| Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) {
+|| 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);
 }
 JVMWrapper("JVM_GetClassDeclaredConstructors");
 JvmtiVMObjectAllocEventCollector oam;
 // Exclude primitive types and array types
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
-|| Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) {
+|| 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);
 }
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 // Primitive type
 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
 }
-Klass* k = Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)));
+Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS;
 }
 JVM_END
 JvmtiVMObjectAllocEventCollector oam;
 // Return null for primitives and arrays
 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
-if (Klass::cast(k)->oop_is_instance()) {
+if (k->oop_is_instance()) {
 instanceKlassHandle k_h(THREAD, k);
 Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL);
 sun_reflect_ConstantPool::set_cp(jcp(), k_h->constants());
 return JNIHandles::make_local(jcp());
 }
 oop r = JNIHandles::resolve(cls);
 assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed");
 if (java_lang_Class::is_primitive(r)) return false;
 Klass* k = java_lang_Class::as_Klass(r);
-assert(Klass::cast(k)->oop_is_instance(), "must be an instance klass");
+assert(k->oop_is_instance(), "must be an instance klass");
-if (! Klass::cast(k)->oop_is_instance()) return false;
+if (! k->oop_is_instance()) return false;
 ResourceMark rm(THREAD);
-const char* name = Klass::cast(k)->name()->as_C_string();
+const char* name = k->name()->as_C_string();
-bool system_class = Klass::cast(k)->class_loader() == NULL;
+bool system_class = k->class_loader() == NULL;
 return JavaAssertions::enabled(name, system_class);
 JVM_END
 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassNameUTF");
 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();
+return k->name()->as_utf8();
 JVM_END
 JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
 JVMWrapper("JVM_GetClassCPTypes");
 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
 // (length is determined by call to JVM_GetClassCPEntriesCount)
-if (Klass::cast(k)->oop_is_instance()) {
+if (k->oop_is_instance()) {
 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.value();
 }
 JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassCPEntriesCount");
 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())
+if (!k->oop_is_instance())
 return 0;
 return InstanceKlass::cast(k)->constants()->length();
 JVM_END
 JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassFieldsCount");
 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())
+if (!k->oop_is_instance())
 return 0;
 return InstanceKlass::cast(k)->java_fields_count();
 JVM_END
 JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassMethodsCount");
 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())
+if (!k->oop_is_instance())
 return 0;
 return InstanceKlass::cast(k)->methods()->length();
 JVM_END
 // Create result array of type [Ljava/lang/Class;
 objArrayOop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), depth, CHECK_NULL);
 // Fill in mirrors corresponding to method holders
 int index = 0;
 while (first != NULL) {
-result->obj_at_put(index++, Klass::cast(first->klass())->java_mirror());
+result->obj_at_put(index++, first->klass()->java_mirror());
 first = first->next;
 }
 assert(index == depth, "just checking");
 return (jobjectArray) JNIHandles::make_local(env, result);
 return true;
 }
 if (access.is_protected()) {
 // See if current_class is a subclass of field_class
-if (Klass::cast(current_class)->is_subclass_of(field_class)) {
+if (current_class->is_subclass_of(field_class)) {
 return true;
 }
 }
 return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class));
 ResourceMark rm(THREAD);
 THROW_0(vmSymbols::java_lang_InvalidClassException());
 }
 // Arrays not allowed here, must use JVM_AllocateNewArray
-if (Klass::cast(java_lang_Class::as_Klass(curr_mirror))->oop_is_array() ||
+if (java_lang_Class::as_Klass(curr_mirror)->oop_is_array() ||
-Klass::cast(java_lang_Class::as_Klass(init_mirror))->oop_is_array()) {
+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_Klass(curr_mirror));
 init_klass->find_method(vmSymbols::object_initializer_name(),
 vmSymbols::void_method_signature()));
 if (m.is_null()) {
 ResourceMark rm(THREAD);
 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(),
-Method::name_and_sig_as_C_string(Klass::cast(init_klass()),
+Method::name_and_sig_as_C_string(init_klass(),
 vmSymbols::object_initializer_name(),
 vmSymbols::void_method_signature()));
 }
 if (curr_klass ==  init_klass && !m->is_public()) {
 // Special handling for primitive objects
 if (java_lang_Class::is_primitive(mirror())) {
 return NULL;
 }
 Klass* k = java_lang_Class::as_Klass(mirror());
-if (!Klass::cast(k)->oop_is_instance()) {
+if (!k->oop_is_instance()) {
 return NULL;
 }
 instanceKlassHandle ik_h(THREAD, k);
 int encl_method_class_idx = ik_h->enclosing_method_class_index();
 if (encl_method_class_idx == 0) {
 return NULL;
 }
 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL);
 objArrayHandle dest(THREAD, dest_o);
 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());
+dest->obj_at_put(0, enc_k->java_mirror());
 int encl_method_method_idx = ik_h->enclosing_method_method_index();
 if (encl_method_method_idx != 0) {
 Symbol* sym = ik_h->constants()->symbol_at(
 extract_low_short_from_int(
 ik_h->constants()->name_and_type_at(encl_method_method_idx)));

changeset 14488	ab48109f7d1b
parent 14391	df0a1573d5bd
child 15097	9db149412e0e