750 return in_ByteSize(InstanceKlass::header_size() * wordSize);
751 }
752
753 #ifndef PRODUCT
754
755 bool Klass::verify_vtable_index(int i) {
756 int limit = vtable_length()/vtableEntry::size();
757 assert(i >= 0 && i < limit, "index %d out of bounds %d", i, limit);
758 return true;
759 }
760
761 bool Klass::verify_itable_index(int i) {
762 assert(is_instance_klass(), "");
763 int method_count = klassItable::method_count_for_interface(this);
764 assert(i >= 0 && i < method_count, "index out of bounds");
765 return true;
766 }
767
768 #endif // PRODUCT
769
770 // The caller of class_loader_and_module_name() (or one of its callers)
771 // must use a ResourceMark in order to correctly free the result.
772 const char* Klass::class_loader_and_module_name() const {
773 const char* delim = "/";
774 size_t delim_len = strlen(delim);
775
776 const char* fqn = external_name();
777 // Length of message to return; always include FQN
778 size_t msglen = strlen(fqn) + 1;
779
780 bool has_cl_name = false;
781 bool has_mod_name = false;
782 bool has_version = false;
783
784 // Use class loader name, if exists and not builtin
785 const char* class_loader_name = "";
786 ClassLoaderData* cld = class_loader_data();
787 assert(cld != NULL, "class_loader_data should not be NULL");
788 if (!cld->is_builtin_class_loader_data()) {
789 // If not builtin, look for name
790 oop loader = class_loader();
791 if (loader != NULL) {
792 oop class_loader_name_oop = java_lang_ClassLoader::name(loader);
793 if (class_loader_name_oop != NULL) {
794 class_loader_name = java_lang_String::as_utf8_string(class_loader_name_oop);
795 if (class_loader_name != NULL && class_loader_name[0] != '\0') {
796 has_cl_name = true;
797 msglen += strlen(class_loader_name) + delim_len;
798 }
799 }
800 }
801 }
802
803 const char* module_name = "";
804 const char* version = "";
805 const Klass* bottom_klass = is_objArray_klass() ?
806 ObjArrayKlass::cast(this)->bottom_klass() : this;
807 if (bottom_klass->is_instance_klass()) {
808 ModuleEntry* module = InstanceKlass::cast(bottom_klass)->module();
809 // Use module name, if exists
810 if (module->is_named()) {
811 has_mod_name = true;
812 module_name = module->name()->as_C_string();
813 msglen += strlen(module_name);
814 // Use version if exists and is not a jdk module
815 if (module->should_show_version()) {
816 has_version = true;
817 version = module->version()->as_C_string();
818 msglen += strlen(version) + 1; // +1 for "@"
819 }
820 }
821 } else {
822 // klass is an array of primitives, so its module is java.base
823 module_name = JAVA_BASE_NAME;
824 }
825
826 if (has_cl_name || has_mod_name) {
827 msglen += delim_len;
828 }
829
830 char* message = NEW_RESOURCE_ARRAY_RETURN_NULL(char, msglen);
831
832 // Just return the FQN if error in allocating string
833 if (message == NULL) {
834 return fqn;
835 }
836
837 jio_snprintf(message, msglen, "%s%s%s%s%s%s%s",
838 class_loader_name,
839 (has_cl_name) ? delim : "",
840 (has_mod_name) ? module_name : "",
841 (has_version) ? "@" : "",
842 (has_version) ? version : "",
843 (has_cl_name || has_mod_name) ? delim : "",
844 fqn);
845 return message;
846 }
|
750 return in_ByteSize(InstanceKlass::header_size() * wordSize);
751 }
752
753 #ifndef PRODUCT
754
755 bool Klass::verify_vtable_index(int i) {
756 int limit = vtable_length()/vtableEntry::size();
757 assert(i >= 0 && i < limit, "index %d out of bounds %d", i, limit);
758 return true;
759 }
760
761 bool Klass::verify_itable_index(int i) {
762 assert(is_instance_klass(), "");
763 int method_count = klassItable::method_count_for_interface(this);
764 assert(i >= 0 && i < method_count, "index out of bounds");
765 return true;
766 }
767
768 #endif // PRODUCT
769
770 // Caller needs ResourceMark
771 // joint_in_module_of_loader provides an optimization if 2 classes are in
772 // the same module to succinctly print out relevant information about their
773 // module name and class loader's name_and_id for error messages.
774 // Format:
775 // <fully-qualified-external-class-name1> and <fully-qualified-external-class-name2>
776 // are in module <module-name>[@<version>]
777 // of loader <loader-name_and_id>[, parent loader <parent-loader-name_and_id>]
778 const char* Klass::joint_in_module_of_loader(const Klass* class2, bool include_parent_loader) const {
779 assert(module() == class2->module(), "classes do not have the same module");
780 const char* class1_name = external_name();
781 size_t len = strlen(class1_name) + 1;
782
783 const char* class2_description = class2->class_in_module_of_loader(true, include_parent_loader);
784 len += strlen(class2_description);
785
786 len += strlen(" and ");
787
788 char* joint_description = NEW_RESOURCE_ARRAY_RETURN_NULL(char, len);
789
790 // Just return the FQN if error when allocating string
791 if (joint_description == NULL) {
792 return class1_name;
793 }
794
795 jio_snprintf(joint_description, len, "%s and %s",
796 class1_name,
797 class2_description);
798
799 return joint_description;
800 }
801
802 // Caller needs ResourceMark
803 // class_in_module_of_loader provides a standard way to include
804 // relevant information about a class, such as its module name as
805 // well as its class loader's name_and_id, in error messages and logging.
806 // Format:
807 // <fully-qualified-external-class-name> is in module <module-name>[@<version>]
808 // of loader <loader-name_and_id>[, parent loader <parent-loader-name_and_id>]
809 const char* Klass::class_in_module_of_loader(bool use_are, bool include_parent_loader) const {
810 // 1. fully qualified external name of class
811 const char* klass_name = external_name();
812 size_t len = strlen(klass_name) + 1;
813
814 // 2. module name + @version
815 const char* module_name = "";
816 const char* version = "";
817 bool has_version = false;
818 bool module_is_named = false;
819 const char* module_name_phrase = "";
820 const Klass* bottom_klass = is_objArray_klass() ?
821 ObjArrayKlass::cast(this)->bottom_klass() : this;
822 if (bottom_klass->is_instance_klass()) {
823 ModuleEntry* module = InstanceKlass::cast(bottom_klass)->module();
824 if (module->is_named()) {
825 module_is_named = true;
826 module_name_phrase = "module ";
827 module_name = module->name()->as_C_string();
828 len += strlen(module_name);
829 // Use version if exists and is not a jdk module
830 if (module->should_show_version()) {
831 has_version = true;
832 version = module->version()->as_C_string();
833 // Include stlen(version) + 1 for the "@"
834 len += strlen(version) + 1;
835 }
836 } else {
837 module_name = UNNAMED_MODULE;
838 len += UNNAMED_MODULE_LEN;
839 }
840 } else {
841 // klass is an array of primitives, module is java.base
842 module_is_named = true;
843 module_name_phrase = "module ";
844 module_name = JAVA_BASE_NAME;
845 len += JAVA_BASE_NAME_LEN;
846 }
847
848 // 3. class loader's name_and_id
849 ClassLoaderData* cld = class_loader_data();
850 assert(cld != NULL, "class_loader_data should not be null");
851 const char* loader_name_and_id = cld->loader_name_and_id();
852 len += strlen(loader_name_and_id);
853
854 // 4. include parent loader information
855 const char* parent_loader_phrase = "";
856 const char* parent_loader_name_and_id = "";
857 if (include_parent_loader &&
858 !cld->is_builtin_class_loader_data()) {
859 oop parent_loader = java_lang_ClassLoader::parent(class_loader());
860 ClassLoaderData *parent_cld = ClassLoaderData::class_loader_data(parent_loader);
861 assert(parent_cld != NULL, "parent's class loader data should not be null");
862 parent_loader_name_and_id = parent_cld->loader_name_and_id();
863 parent_loader_phrase = ", parent loader ";
864 len += strlen(parent_loader_phrase) + strlen(parent_loader_name_and_id);
865 }
866
867 // Start to construct final full class description string
868 len += ((use_are) ? strlen(" are in ") : strlen(" is in "));
869 len += strlen(module_name_phrase) + strlen(" of loader ");
870
871 char* class_description = NEW_RESOURCE_ARRAY_RETURN_NULL(char, len);
872
873 // Just return the FQN if error when allocating string
874 if (class_description == NULL) {
875 return klass_name;
876 }
877
878 jio_snprintf(class_description, len, "%s %s in %s%s%s%s of loader %s%s%s",
879 klass_name,
880 (use_are) ? "are" : "is",
881 module_name_phrase,
882 module_name,
883 (has_version) ? "@" : "",
884 (has_version) ? version : "",
885 loader_name_and_id,
886 parent_loader_phrase,
887 parent_loader_name_and_id);
888
889 return class_description;
890 }
|