814 "Incorrect java.lang.Module specification while creating mirror");
815 set_module(mirror(), module());
816 }
817 }
818
819 void java_lang_Class::create_mirror(Klass* k, Handle class_loader,
820 Handle module, Handle protection_domain, TRAPS) {
821 assert(k->java_mirror() == NULL, "should only assign mirror once");
822 // Use this moment of initialization to cache modifier_flags also,
823 // to support Class.getModifiers(). Instance classes recalculate
824 // the cached flags after the class file is parsed, but before the
825 // class is put into the system dictionary.
826 int computed_modifiers = k->compute_modifier_flags(CHECK);
827 k->set_modifier_flags(computed_modifiers);
828 // Class_klass has to be loaded because it is used to allocate
829 // the mirror.
830 if (SystemDictionary::Class_klass_loaded()) {
831 // Allocate mirror (java.lang.Class instance)
832 oop mirror_oop = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK);
833 Handle mirror(THREAD, mirror_oop);
834
835 // Setup indirection from mirror->klass
836 if (k != NULL) {
837 java_lang_Class::set_klass(mirror(), k);
838 }
839
840 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
841 assert(oop_size(mirror()) == mk->instance_size(k), "should have been set");
842
843 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
844
845 // It might also have a component mirror. This mirror must already exist.
846 if (k->is_array_klass()) {
847 oop comp_mirror;
848 if (k->is_typeArray_klass()) {
849 BasicType type = TypeArrayKlass::cast(k)->element_type();
850 comp_mirror = Universe::java_mirror(type);
851 } else {
852 assert(k->is_objArray_klass(), "Must be");
853 Klass* element_klass = ObjArrayKlass::cast(k)->element_klass();
854 assert(element_klass != NULL, "Must have an element klass");
855 comp_mirror = element_klass->java_mirror();
856 }
857 assert(comp_mirror != NULL, "must have a mirror");
858
859 // Two-way link between the array klass and its component mirror:
860 // (array_klass) k -> mirror -> component_mirror -> array_klass -> k
861 set_component_mirror(mirror(), comp_mirror);
862 set_array_klass(comp_mirror, k);
863 } else {
864 assert(k->is_instance_klass(), "Must be");
865
866 initialize_mirror_fields(k, mirror, protection_domain, THREAD);
867 if (HAS_PENDING_EXCEPTION) {
868 // If any of the fields throws an exception like OOM remove the klass field
869 // from the mirror so GC doesn't follow it after the klass has been deallocated.
870 // This mirror looks like a primitive type, which logically it is because it
871 // it represents no class.
872 java_lang_Class::set_klass(mirror(), NULL);
873 return;
874 }
875 }
876
877 // set the classLoader field in the java_lang_Class instance
878 assert(class_loader() == k->class_loader(), "should be same");
879 set_class_loader(mirror(), class_loader());
880
881 // set the module field in the java_lang_Class instance
882 set_mirror_module_field(k, mirror, module, THREAD);
883
884 // Setup indirection from klass->mirror last
885 // after any exceptions can happen during allocations.
886 if (k != NULL) {
887 k->set_java_mirror(mirror());
888 }
889 } else {
890 if (fixup_mirror_list() == NULL) {
891 GrowableArray<Klass*>* list =
892 new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true);
893 set_fixup_mirror_list(list);
894 }
895 fixup_mirror_list()->push(k);
896 }
897 }
898
899 void java_lang_Class::fixup_module_field(Klass* k, Handle module) {
900 assert(_module_offset != 0, "must have been computed already");
901 java_lang_Class::set_module(k->java_mirror(), module());
902 }
903
904 int java_lang_Class::oop_size(oop java_class) {
905 assert(_oop_size_offset != 0, "must be set");
906 int size = java_class->int_field(_oop_size_offset);
907 assert(size > 0, "Oop size must be greater than zero, not %d", size);
1071 if (is_primitive(java_class)) {
1072 name = type2name(primitive_type(java_class));
1073 } else {
1074 name = as_Klass(java_class)->external_name();
1075 }
1076 if (name == NULL) {
1077 name = "<null>";
1078 }
1079 return name;
1080 }
1081
1082 Klass* java_lang_Class::array_klass(oop java_class) {
1083 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
1084 assert(k == NULL || k->is_klass() && k->is_array_klass(), "should be array klass");
1085 return k;
1086 }
1087
1088
1089 void java_lang_Class::set_array_klass(oop java_class, Klass* klass) {
1090 assert(klass->is_klass() && klass->is_array_klass(), "should be array klass");
1091 java_class->metadata_field_put(_array_klass_offset, klass);
1092 }
1093
1094
1095 bool java_lang_Class::is_primitive(oop java_class) {
1096 // should assert:
1097 //assert(java_lang_Class::is_instance(java_class), "must be a Class object");
1098 bool is_primitive = (java_class->metadata_field(_klass_offset) == NULL);
1099
1100 #ifdef ASSERT
1101 if (is_primitive) {
1102 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
1103 assert(k == NULL || is_java_primitive(ArrayKlass::cast(k)->element_type()),
1104 "Should be either the T_VOID primitive or a java primitive");
1105 }
1106 #endif
1107
1108 return is_primitive;
1109 }
1110
1111
|
814 "Incorrect java.lang.Module specification while creating mirror");
815 set_module(mirror(), module());
816 }
817 }
818
819 void java_lang_Class::create_mirror(Klass* k, Handle class_loader,
820 Handle module, Handle protection_domain, TRAPS) {
821 assert(k->java_mirror() == NULL, "should only assign mirror once");
822 // Use this moment of initialization to cache modifier_flags also,
823 // to support Class.getModifiers(). Instance classes recalculate
824 // the cached flags after the class file is parsed, but before the
825 // class is put into the system dictionary.
826 int computed_modifiers = k->compute_modifier_flags(CHECK);
827 k->set_modifier_flags(computed_modifiers);
828 // Class_klass has to be loaded because it is used to allocate
829 // the mirror.
830 if (SystemDictionary::Class_klass_loaded()) {
831 // Allocate mirror (java.lang.Class instance)
832 oop mirror_oop = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK);
833 Handle mirror(THREAD, mirror_oop);
834 Handle comp_mirror;
835
836 // Setup indirection from mirror->klass
837 if (k != NULL) {
838 java_lang_Class::set_klass(mirror(), k);
839 }
840
841 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
842 assert(oop_size(mirror()) == mk->instance_size(k), "should have been set");
843
844 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
845
846 // It might also have a component mirror. This mirror must already exist.
847 if (k->is_array_klass()) {
848 if (k->is_typeArray_klass()) {
849 BasicType type = TypeArrayKlass::cast(k)->element_type();
850 comp_mirror = Handle(THREAD, Universe::java_mirror(type));
851 } else {
852 assert(k->is_objArray_klass(), "Must be");
853 Klass* element_klass = ObjArrayKlass::cast(k)->element_klass();
854 assert(element_klass != NULL, "Must have an element klass");
855 comp_mirror = Handle(THREAD, element_klass->java_mirror());
856 }
857 assert(comp_mirror() != NULL, "must have a mirror");
858
859 // Two-way link between the array klass and its component mirror:
860 // (array_klass) k -> mirror -> component_mirror -> array_klass -> k
861 set_component_mirror(mirror(), comp_mirror());
862 // Set after k->java_mirror() is published, because compiled code running
863 // concurrently doesn't expect a k to have a null java_mirror.
864 // set_array_klass(comp_mirror, k);
865 } else {
866 assert(k->is_instance_klass(), "Must be");
867
868 initialize_mirror_fields(k, mirror, protection_domain, THREAD);
869 if (HAS_PENDING_EXCEPTION) {
870 // If any of the fields throws an exception like OOM remove the klass field
871 // from the mirror so GC doesn't follow it after the klass has been deallocated.
872 // This mirror looks like a primitive type, which logically it is because it
873 // it represents no class.
874 java_lang_Class::set_klass(mirror(), NULL);
875 return;
876 }
877 }
878
879 // set the classLoader field in the java_lang_Class instance
880 assert(class_loader() == k->class_loader(), "should be same");
881 set_class_loader(mirror(), class_loader());
882
883 // set the module field in the java_lang_Class instance
884 set_mirror_module_field(k, mirror, module, THREAD);
885
886 // Setup indirection from klass->mirror
887 // after any exceptions can happen during allocations.
888 k->set_java_mirror(mirror());
889 if (comp_mirror() != NULL) {
890 set_array_klass(comp_mirror(), k);
891 }
892 } else {
893 if (fixup_mirror_list() == NULL) {
894 GrowableArray<Klass*>* list =
895 new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true);
896 set_fixup_mirror_list(list);
897 }
898 fixup_mirror_list()->push(k);
899 }
900 }
901
902 void java_lang_Class::fixup_module_field(Klass* k, Handle module) {
903 assert(_module_offset != 0, "must have been computed already");
904 java_lang_Class::set_module(k->java_mirror(), module());
905 }
906
907 int java_lang_Class::oop_size(oop java_class) {
908 assert(_oop_size_offset != 0, "must be set");
909 int size = java_class->int_field(_oop_size_offset);
910 assert(size > 0, "Oop size must be greater than zero, not %d", size);
1074 if (is_primitive(java_class)) {
1075 name = type2name(primitive_type(java_class));
1076 } else {
1077 name = as_Klass(java_class)->external_name();
1078 }
1079 if (name == NULL) {
1080 name = "<null>";
1081 }
1082 return name;
1083 }
1084
1085 Klass* java_lang_Class::array_klass(oop java_class) {
1086 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
1087 assert(k == NULL || k->is_klass() && k->is_array_klass(), "should be array klass");
1088 return k;
1089 }
1090
1091
1092 void java_lang_Class::set_array_klass(oop java_class, Klass* klass) {
1093 assert(klass->is_klass() && klass->is_array_klass(), "should be array klass");
1094 java_class->metadata_field_put_volatile(_array_klass_offset, klass);
1095 }
1096
1097
1098 bool java_lang_Class::is_primitive(oop java_class) {
1099 // should assert:
1100 //assert(java_lang_Class::is_instance(java_class), "must be a Class object");
1101 bool is_primitive = (java_class->metadata_field(_klass_offset) == NULL);
1102
1103 #ifdef ASSERT
1104 if (is_primitive) {
1105 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
1106 assert(k == NULL || is_java_primitive(ArrayKlass::cast(k)->element_type()),
1107 "Should be either the T_VOID primitive or a java primitive");
1108 }
1109 #endif
1110
1111 return is_primitive;
1112 }
1113
1114
|