8169559: Add class loader names to relevant VM messages

Added new method class_in_module_of_loader to provide a standard format for class information within error messages.

Reviewed-by: goetz, hseigel, mchung

src/hotspot/share/oops/klass.cpp

@@ -774,80 +774,124 @@ bool Klass::verify_itable_index(int i) {
 
 #endif // PRODUCT
 
-// The caller of class_loader_and_module_name() (or one of its callers)
-// must use a ResourceMark in order to correctly free the result.
-const char* Klass::class_loader_and_module_name() const {
-  const char* delim = "/";
-  size_t delim_len = strlen(delim);
+// Caller needs ResourceMark
+// joint_in_module_of_loader provides an optimization if 2 classes are in
+// the same module to succinctly print out relevant information about their
+// module name and class loader's name_and_id for error messages.
+// Format:
+//   <fully-qualified-external-class-name1> and <fully-qualified-external-class-name2>
+//                      are in module <module-name>[@<version>]
+//                      of loader <loader-name_and_id>[, parent loader <parent-loader-name_and_id>]
+const char* Klass::joint_in_module_of_loader(const Klass* class2, bool include_parent_loader) const {
+  assert(module() == class2->module(), "classes do not have the same module");
+  const char* class1_name = external_name();
+  size_t len = strlen(class1_name) + 1;
 
-  const char* fqn = external_name();
-  // Length of message to return; always include FQN
-  size_t msglen = strlen(fqn) + 1;
+  const char* class2_description = class2->class_in_module_of_loader(true, include_parent_loader);
+  len += strlen(class2_description);
 
-  bool has_cl_name = false;
-  bool has_mod_name = false;
-  bool has_version = false;
+  len += strlen(" and ");
 
-  // Use class loader name, if exists and not builtin
-  const char* class_loader_name = "";
-  ClassLoaderData* cld = class_loader_data();
-  assert(cld != NULL, "class_loader_data should not be NULL");
-  if (!cld->is_builtin_class_loader_data()) {
-    // If not builtin, look for name
-    oop loader = class_loader();
-    if (loader != NULL) {
-      oop class_loader_name_oop = java_lang_ClassLoader::name(loader);
-      if (class_loader_name_oop != NULL) {
-        class_loader_name = java_lang_String::as_utf8_string(class_loader_name_oop);
-        if (class_loader_name != NULL && class_loader_name[0] != '\0') {
-          has_cl_name = true;
-          msglen += strlen(class_loader_name) + delim_len;
-        }
-      }
-    }
+  char* joint_description = NEW_RESOURCE_ARRAY_RETURN_NULL(char, len);
+
+  // Just return the FQN if error when allocating string
+  if (joint_description == NULL) {
+    return class1_name;
   }
 
+  jio_snprintf(joint_description, len, "%s and %s",
+               class1_name,
+               class2_description);
+
+  return joint_description;
+}
+
+// Caller needs ResourceMark
+// class_in_module_of_loader provides a standard way to include
+// relevant information about a class, such as its module name as
+// well as its class loader's name_and_id, in error messages and logging.
+// Format:
+//   <fully-qualified-external-class-name> is in module <module-name>[@<version>]
+//                                         of loader <loader-name_and_id>[, parent loader <parent-loader-name_and_id>]
+const char* Klass::class_in_module_of_loader(bool use_are, bool include_parent_loader) const {
+  // 1. fully qualified external name of class
+  const char* klass_name = external_name();
+  size_t len = strlen(klass_name) + 1;
+
+  // 2. module name + @version
   const char* module_name = "";
   const char* version = "";
+  bool has_version = false;
+  bool module_is_named = false;
+  const char* module_name_phrase = "";
   const Klass* bottom_klass = is_objArray_klass() ?
-    ObjArrayKlass::cast(this)->bottom_klass() : this;
+                                ObjArrayKlass::cast(this)->bottom_klass() : this;
   if (bottom_klass->is_instance_klass()) {
     ModuleEntry* module = InstanceKlass::cast(bottom_klass)->module();
-    // Use module name, if exists
     if (module->is_named()) {
-      has_mod_name = true;
+      module_is_named = true;
+      module_name_phrase = "module ";
       module_name = module->name()->as_C_string();
-      msglen += strlen(module_name);
+      len += strlen(module_name);
       // Use version if exists and is not a jdk module
       if (module->should_show_version()) {
         has_version = true;
         version = module->version()->as_C_string();
-        msglen += strlen(version) + 1; // +1 for "@"
+        // Include stlen(version) + 1 for the "@"
+        len += strlen(version) + 1;
       }
+    } else {
+      module_name = UNNAMED_MODULE;
+      len += UNNAMED_MODULE_LEN;
     }
   } else {
-    // klass is an array of primitives, so its module is java.base
+    // klass is an array of primitives, module is java.base
+    module_is_named = true;
+    module_name_phrase = "module ";
     module_name = JAVA_BASE_NAME;
+    len += JAVA_BASE_NAME_LEN;
   }
 
-  if (has_cl_name || has_mod_name) {
-    msglen += delim_len;
+  // 3. class loader's name_and_id
+  ClassLoaderData* cld = class_loader_data();
+  assert(cld != NULL, "class_loader_data should not be null");
+  const char* loader_name_and_id = cld->loader_name_and_id();
+  len += strlen(loader_name_and_id);
+
+  // 4. include parent loader information
+  const char* parent_loader_phrase = "";
+  const char* parent_loader_name_and_id = "";
+  if (include_parent_loader &&
+      !cld->is_builtin_class_loader_data()) {
+    oop parent_loader = java_lang_ClassLoader::parent(class_loader());
+    ClassLoaderData *parent_cld = ClassLoaderData::class_loader_data(parent_loader);
+    assert(parent_cld != NULL, "parent's class loader data should not be null");
+    parent_loader_name_and_id = parent_cld->loader_name_and_id();
+    parent_loader_phrase = ", parent loader ";
+    len += strlen(parent_loader_phrase) + strlen(parent_loader_name_and_id);
   }
 
-  char* message = NEW_RESOURCE_ARRAY_RETURN_NULL(char, msglen);
+  // Start to construct final full class description string
+  len += ((use_are) ? strlen(" are in ") : strlen(" is in "));
+  len += strlen(module_name_phrase) + strlen(" of loader ");
 
-  // Just return the FQN if error in allocating string
-  if (message == NULL) {
-    return fqn;
+  char* class_description = NEW_RESOURCE_ARRAY_RETURN_NULL(char, len);
+
+  // Just return the FQN if error when allocating string
+  if (class_description == NULL) {
+    return klass_name;
   }
 
-  jio_snprintf(message, msglen, "%s%s%s%s%s%s%s",
-               class_loader_name,
-               (has_cl_name) ? delim : "",
-               (has_mod_name) ? module_name : "",
+  jio_snprintf(class_description, len, "%s %s in %s%s%s%s of loader %s%s%s",
+               klass_name,
+               (use_are) ? "are" : "is",
+               module_name_phrase,
+               module_name,
                (has_version) ? "@" : "",
                (has_version) ? version : "",
-               (has_cl_name || has_mod_name) ? delim : "",
-               fqn);
-  return message;
+               loader_name_and_id,
+               parent_loader_phrase,
+               parent_loader_name_and_id);
+
+  return class_description;
 }