--- old/src/share/vm/classfile/moduleEntry.cpp 2016-11-10 14:24:02.814739794 -0500 +++ new/src/share/vm/classfile/moduleEntry.cpp 2016-11-10 14:24:02.322739811 -0500 @@ -54,6 +54,18 @@ } } +bool ModuleEntry::is_non_jdk_module() { + ResourceMark rm; + if (location() != NULL) { + const char* loc = ""; + loc = location()->as_C_string(); + if (strncmp(loc, "jrt:/java.", 10) != 0 && strncmp(loc, "jrt:/jdk.", 9) != 0) { + return true; + } + } + return false; +} + void ModuleEntry::set_version(Symbol* version) { if (_version != NULL) { // _version symbol's refcounts are managed by ModuleEntry, --- old/src/share/vm/classfile/moduleEntry.hpp 2016-11-10 14:24:04.394739739 -0500 +++ new/src/share/vm/classfile/moduleEntry.hpp 2016-11-10 14:24:03.902739756 -0500 @@ -100,6 +100,7 @@ Symbol* location() const { return _location; } void set_location(Symbol* location); + bool is_non_jdk_module(); bool can_read(ModuleEntry* m) const; bool has_reads() const; --- old/src/share/vm/classfile/systemDictionary.cpp 2016-11-10 14:24:05.990739683 -0500 +++ new/src/share/vm/classfile/systemDictionary.cpp 2016-11-10 14:24:05.486739701 -0500 @@ -2897,11 +2897,11 @@ // caller needs ResourceMark const char* SystemDictionary::loader_name(const oop loader) { return ((loader) == NULL ? "" : - InstanceKlass::cast((loader)->klass())->name()->as_C_string()); + InstanceKlass::cast((loader)->klass())->name()->as_C_string()); } // caller needs ResourceMark const char* SystemDictionary::loader_name(const ClassLoaderData* loader_data) { return (loader_data->class_loader() == NULL ? "" : - InstanceKlass::cast((loader_data->class_loader())->klass())->name()->as_C_string()); + SystemDictionary::loader_name(loader_data->class_loader())); } --- old/src/share/vm/runtime/sharedRuntime.cpp 2016-11-10 14:24:07.614739626 -0500 +++ new/src/share/vm/runtime/sharedRuntime.cpp 2016-11-10 14:24:07.118739644 -0500 @@ -55,6 +55,7 @@ #include "runtime/handles.inline.hpp" #include "runtime/init.hpp" #include "runtime/interfaceSupport.hpp" +#include "runtime/java.hpp" #include "runtime/javaCalls.hpp" #include "runtime/sharedRuntime.hpp" #include "runtime/stubRoutines.hpp" @@ -1932,45 +1933,103 @@ cc.index(), thread); return generate_class_cast_message(caster_klass, target_klass); } +#define CLASS_LOADER_NAME_DELIMITER "/" +#define CLASS_LOADER_NAME_DELIMITER_LENGTH strlen(CLASS_LOADER_NAME_DELIMITER) + +// 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* class_loader_and_module_name(Klass* klass, Klass* base_klass) { + const char* fqn = klass->external_name(); + // Length of message to return; always include FQN + size_t msglen = strlen(fqn) + 1; + + bool has_cl_name = false; + bool has_mod_name = false; + bool has_version = false; + + // Use class loader name, if exists and not builtin + const char* class_loader_name = ""; + ClassLoaderData* cld = klass->class_loader_data(); + if (cld == NULL || !cld->is_builtin_class_loader_data()) { + // If not builtin, look for internal name + oop loader = klass->class_loader(); + if (loader != NULL) { + oopDesc* class_loader = java_lang_ClassLoader::name(loader); + if (class_loader != NULL && class_loader->klass() != NULL) { + class_loader_name = class_loader->klass()->internal_name(); + if (class_loader_name != NULL && class_loader_name[0] != '\0') { + has_cl_name = true; + msglen += strlen(class_loader_name) + CLASS_LOADER_NAME_DELIMITER_LENGTH; + } + } + } + } + + const char* module_name = ""; + const char* version = ""; + if (base_klass->is_instance_klass()) { + ModuleEntry* module = InstanceKlass::cast(base_klass)->module(); + // Use module name, if exists + if (module->is_named()) { + has_mod_name = true; + module_name = module->name()->as_C_string(); + msglen += strlen(module_name); + // Use version if exists and is not a jdk module + if (module->is_non_jdk_module() && module->version() != NULL) { + has_version = true; + version = module->version()->as_C_string(); + msglen += strlen("@") + strlen(version); + } + } + } else { + module_name = "java.base"; + } + + if (has_cl_name || has_mod_name) { + msglen += CLASS_LOADER_NAME_DELIMITER_LENGTH; + } + + char* message = NEW_RESOURCE_ARRAY(char, msglen); + + // Just return the FQN if error in allocating string + if (message == NULL) { + return fqn; + } + + jio_snprintf(message, msglen, "%s%s%s%s%s%s%s", + class_loader_name, + (has_cl_name) ? CLASS_LOADER_NAME_DELIMITER : "", + (has_mod_name) ? module_name : "", + (has_version) ? "@" : "", + (has_version) ? version : "", + (has_cl_name || has_mod_name) ? CLASS_LOADER_NAME_DELIMITER : "", + fqn); + return message; +} char* SharedRuntime::generate_class_cast_message( Klass* caster_klass, Klass* target_klass) { - const char* caster_klass_name = caster_klass->external_name(); Klass* c_klass = caster_klass->is_objArray_klass() ? ObjArrayKlass::cast(caster_klass)->bottom_klass() : caster_klass; - ModuleEntry* caster_module; - const char* caster_module_name; - if (c_klass->is_instance_klass()) { - caster_module = InstanceKlass::cast(c_klass)->module(); - caster_module_name = caster_module->is_named() ? - caster_module->name()->as_C_string() : UNNAMED_MODULE; - } else { - caster_module_name = "java.base"; - } - const char* target_klass_name = target_klass->external_name(); + const char* caster_name = class_loader_and_module_name(caster_klass, c_klass); + Klass* t_klass = target_klass->is_objArray_klass() ? ObjArrayKlass::cast(target_klass)->bottom_klass() : target_klass; - ModuleEntry* target_module; - const char* target_module_name; - if (t_klass->is_instance_klass()) { - target_module = InstanceKlass::cast(t_klass)->module(); - target_module_name = target_module->is_named() ? - target_module->name()->as_C_string(): UNNAMED_MODULE; - } else { - target_module_name = "java.base"; - } - - size_t msglen = strlen(caster_klass_name) + strlen(caster_module_name) + - strlen(target_klass_name) + strlen(target_module_name) + 50; + const char* target_name = class_loader_and_module_name(target_klass, t_klass); + + size_t msglen = strlen(caster_name) + strlen(" cannot be cast to ") + strlen(target_name) + 1; char* message = NEW_RESOURCE_ARRAY(char, msglen); if (NULL == message) { // Shouldn't happen, but don't cause even more problems if it does - message = const_cast(caster_klass_name); + message = const_cast(caster_klass->external_name()); } else { - jio_snprintf(message, msglen, "%s (in module: %s) cannot be cast to %s (in module: %s)", - caster_klass_name, caster_module_name, target_klass_name, target_module_name); + jio_snprintf(message, + msglen, + "%s cannot be cast to %s", + caster_name, + target_name); } return message; } --- old/test/runtime/modules/CCE_module_msg.java 2016-11-10 14:24:09.242739570 -0500 +++ new/test/runtime/modules/CCE_module_msg.java 2016-11-10 14:24:08.750739587 -0500 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,17 +23,31 @@ /** * @test - * @run main/othervm CCE_module_msg + * @modules java.base/jdk.internal.misc + * @library /test/lib .. + * @compile p2/c2.java + * @compile p1/c1.java + * @build sun.hotspot.WhiteBox + * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @run main ClassFileInstaller sun.hotspot.WhiteBox + * sun.hotspot.WhiteBox$WhiteBoxPermission + * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI CCE_module_msg */ +import java.lang.reflect.Module; +import static jdk.test.lib.Asserts.*; + // Test that the message in a runtime ClassCastException contains module info. public class CCE_module_msg { - public static void main(String[] args) { - invalidCastTest(); + public static void main(String[] args) throws Throwable { + // Should not display version + invalidObjectToDerived(); + // Should display version + invalidClassToString(); } - public static void invalidCastTest() { + public static void invalidObjectToDerived() { java.lang.Object instance = new java.lang.Object(); int left = 23; int right = 42; @@ -44,7 +58,45 @@ throw new RuntimeException("ClassCastException wasn't thrown, test failed."); } catch (ClassCastException cce) { System.out.println(cce.getMessage()); - if (!cce.getMessage().contains("java.lang.Object (in module: java.base) cannot be cast")) { + if (!cce.getMessage().contains("java.base/java.lang.Object cannot be cast to Derived")) { + throw new RuntimeException("Wrong message: " + cce.getMessage()); + } + } + } + + public static void invalidClassToString() throws Throwable { + Object m1, m2; + + // Get the java.lang.reflect.Module object for module java.base. + Class jlObject = Class.forName("java.lang.Object"); + Object jlObject_jlrM = jlObject.getModule(); + assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + + // Get the class loader for AccessCheckRead and assume it's also used to + // load classes p1.c1 and p2.c2. + ClassLoader this_cldr = AccessCheckRead.class.getClassLoader(); + + // Define a module for p1. + m1 = ModuleHelper.ModuleObject("module1", this_cldr, new String[] { "p1" }); + assertNotNull(m1, "Module should not be null"); + ModuleHelper.DefineModule(m1, "9.0", "m1/here", new String[] { "p1" }); + ModuleHelper.AddReadsModule(m1, jlObject_jlrM); + + // Define a module for p2. + m2 = ModuleHelper.ModuleObject("module2", this_cldr, new String[] { "p2" }); + assertNotNull(m2, "Module should not be null"); + ModuleHelper.DefineModule(m2, "9.0", "m2/there", new String[] { "p2" }); + ModuleHelper.AddReadsModule(m2, jlObject_jlrM); + + try { + ModuleHelper.AddModuleExportsToAll(m2, "p2"); + Object p2Obj = new p2.c2(); + System.out.println((String)p2Obj); + } catch (ClassCastException cce) { + System.out.println(cce.getMessage()); + if (cce.getMessage().contains("module2/p2.c2") || + !(cce.getMessage().contains("module2@") && + cce.getMessage().contains("/p2.c2 cannot be cast to java.base/java.lang.String"))) { throw new RuntimeException("Wrong message: " + cce.getMessage()); } }