graal-compiler: src/share/vm/classfile/javaClasses.cpp comparison

comparison src/share/vm/classfile/javaClasses.cpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	3ac7d10a6572 f2110083203d
children	6b0fd0964b87

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 to_buffer->char_at_put(index, c);
 }
 return string;
 }
-jchar* java_lang_String::as_unicode_string(oop java_string, int& length) {
+jchar* java_lang_String::as_unicode_string(oop java_string, int& length, TRAPS) {
 typeArrayOop value  = java_lang_String::value(java_string);
 int          offset = java_lang_String::offset(java_string);
 length = java_lang_String::length(java_string);
-jchar* result = NEW_RESOURCE_ARRAY(jchar, length);
+jchar* result = NEW_RESOURCE_ARRAY_RETURN_NULL(jchar, length);
-for (int index = 0; index < length; index++) {
+if (result != NULL) {
-result[index] = value->char_at(index + offset);
+for (int index = 0; index < length; index++) {
+result[index] = value->char_at(index + offset);
+}
+} else {
+THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string");
 }
 return result;
 }
 unsigned int java_lang_String::hash_code(oop java_string) {
 void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
 assert(InstanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
 // If the offset was read from the shared archive, it was fixed up already
 if (!k->is_shared()) {
 if (k->oop_is_instance()) {
 // During bootstrap, java.lang.Class wasn't loaded so static field
 // offsets were computed without the size added it.  Go back and
 // update all the static field offsets to included the size.
 for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) {
 if (fs.access_flags().is_static()) {
 int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields();
 fs.set_offset(real_offset);
+}
 }
 }
 }
-}
+create_mirror(k, Handle(NULL), CHECK);
-create_mirror(k, CHECK);
+}
-}
+oop java_lang_Class::create_mirror(KlassHandle k, Handle protection_domain, TRAPS) {
-oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
 assert(k->java_mirror() == NULL, "should only assign mirror once");
 // Use this moment of initialization to cache modifier_flags also,
 // to support Class.getModifiers().  Instance classes recalculate
 // the cached flags after the class file is parsed, but before the
 // class is put into the system dictionary.
 // Two-way link between the array klass and its component mirror:
 ArrayKlass::cast(k())->set_component_mirror(comp_mirror());
 set_array_klass(comp_mirror(), k());
 } else {
 assert(k->oop_is_instance(), "Must be");
+// Allocate a simple java object for a lock.
+// This needs to be a java object because during class initialization
+// it can be held across a java call.
+typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK_NULL);
+set_init_lock(mirror(), r);
+// Set protection domain also
+set_protection_domain(mirror(), protection_domain());
 // Initialize static fields
 InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);
 }
 return mirror();
 } else {
 }
 void java_lang_Class::set_static_oop_field_count(oop java_class, int size) {
 assert(_static_oop_field_count_offset != 0, "must be set");
 java_class->int_field_put(_static_oop_field_count_offset, size);
 }
+oop java_lang_Class::protection_domain(oop java_class) {
+assert(_protection_domain_offset != 0, "must be set");
+return java_class->obj_field(_protection_domain_offset);
+}
+void java_lang_Class::set_protection_domain(oop java_class, oop pd) {
+assert(_protection_domain_offset != 0, "must be set");
+java_class->obj_field_put(_protection_domain_offset, pd);
+}
+oop java_lang_Class::init_lock(oop java_class) {
+assert(_init_lock_offset != 0, "must be set");
+return java_class->obj_field(_init_lock_offset);
+}
+void java_lang_Class::set_init_lock(oop java_class, oop init_lock) {
+assert(_init_lock_offset != 0, "must be set");
+java_class->obj_field_put(_init_lock_offset, init_lock);
+}
+objArrayOop java_lang_Class::signers(oop java_class) {
+assert(_signers_offset != 0, "must be set");
+return (objArrayOop)java_class->obj_field(_signers_offset);
+}
+void java_lang_Class::set_signers(oop java_class, objArrayOop signers) {
+assert(_signers_offset != 0, "must be set");
+java_class->obj_field_put(_signers_offset, (oop)signers);
+}
 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
 // This should be improved by adding a field at the Java level or by
 // introducing a new VM klass (see comment in ClassFileParser)
 oop java_class = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0);
 }
 }
 // Read thread status value from threadStatus field in java.lang.Thread java class.
 java_lang_Thread::ThreadStatus java_lang_Thread::get_thread_status(oop java_thread) {
-assert(Thread::current()->is_VM_thread() ||
+assert(Thread::current()->is_Watcher_thread() || Thread::current()->is_VM_thread() ||
 JavaThread::current()->thread_state() == _thread_in_vm,
 "Java Thread is not running in vm");
 // The threadStatus is only present starting in 1.5
 if (_thread_status_offset > 0) {
 return (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset);
 Metadata* java_lang_invoke_MemberName::vmtarget(oop mname) {
 assert(is_instance(mname), "wrong type");
 return (Metadata*)mname->address_field(_vmtarget_offset);
 }
+#if INCLUDE_JVMTI
+// Can be executed on VM thread only
+void java_lang_invoke_MemberName::adjust_vmtarget(oop mname, Metadata* ref) {
+assert((is_instance(mname) && (flags(mname) & (MN_IS_METHOD | MN_IS_CONSTRUCTOR)) > 0), "wrong type");
+assert(Thread::current()->is_VM_thread(), "not VM thread");
+mname->address_field_put(_vmtarget_offset, (address)ref);
+}
+#endif // INCLUDE_JVMTI
 void java_lang_invoke_MemberName::set_vmtarget(oop mname, Metadata* ref) {
 assert(is_instance(mname), "wrong type");
 // check the type of the vmtarget
 oop dependency = NULL;
 if (ref != NULL) {
 int java_lang_Class::_klass_offset;
 int java_lang_Class::_array_klass_offset;
 int java_lang_Class::_oop_size_offset;
 int java_lang_Class::_static_oop_field_count_offset;
+int java_lang_Class::_protection_domain_offset;
+int java_lang_Class::_init_lock_offset;
+int java_lang_Class::_signers_offset;
 #ifdef GRAAL
 int java_lang_Class::_graal_mirror_offset;
 #endif
 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL;
 int java_lang_Throwable::backtrace_offset;

Mercurial > hg > graal-compiler

comparison src/share/vm/classfile/javaClasses.cpp @ 10408:836a62f43af9