< prev index next >

src/share/vm/classfile/javaClasses.cpp

Print this page




 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 


< prev index next >