jdk-sandbox: comparison hotspot/src/share/vm/classfile/modules.cpp

equal deleted inserted replaced

-:033b9f74b930
+:add500644443
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "logging/log.hpp"
 #include "memory/resourceArea.hpp"
 #include "oops/instanceKlass.hpp"
-#include "oops/objArrayKlass.hpp"
-#include "oops/objArrayOop.inline.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/reflection.hpp"
 #include "utilities/stringUtils.hpp"
 #include "utilities/utf8.hpp"
-static bool verify_module_name(char *module_name) {
+static bool verify_module_name(const char *module_name) {
 if (module_name == NULL) return false;
 int len = (int)strlen(module_name);
 return (len > 0 && len <= Symbol::max_length());
 }
-bool Modules::verify_package_name(char *package_name) {
+bool Modules::verify_package_name(const char* package_name) {
 if (package_name == NULL) return false;
 int len = (int)strlen(package_name);
 return (len > 0 && len <= Symbol::max_length() &&
-UTF8::is_legal_utf8((unsigned char *)package_name, len, false) &&
+UTF8::is_legal_utf8((const unsigned char *)package_name, len, false) &&
 ClassFileParser::verify_unqualified_name(package_name, len,
 ClassFileParser::LegalClass));
 }
 static char* get_module_name(oop module, TRAPS) {
 "module is not an instance of type java.lang.reflect.Module");
 }
 return java_lang_reflect_Module::module_entry(module_h(), CHECK_NULL);
 }
-static PackageEntry* get_package_entry(ModuleEntry* module_entry, jstring package, TRAPS) {
+static PackageEntry* get_package_entry(ModuleEntry* module_entry, const char* package_name, TRAPS) {
 ResourceMark rm(THREAD);
-if (package == NULL) return NULL;
-const char *package_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(package));
 if (package_name == NULL) return NULL;
 TempNewSymbol pkg_symbol = SymbolTable::new_symbol(package_name, CHECK_NULL);
 PackageEntryTable* package_entry_table = module_entry->loader_data()->packages();
 assert(package_entry_table != NULL, "Unexpected null package entry table");
 return package_entry_table->lookup_only(pkg_symbol);
 PackageEntry* res = get_package_entry_by_name(package, h_loader, CHECK_false);
 return res != NULL;
 }
 static void define_javabase_module(jobject module, jstring version,
-jstring location, jobjectArray packages, TRAPS) {
+jstring location, const char* const* packages,
+jsize num_packages, TRAPS) {
 ResourceMark rm(THREAD);
 Handle module_handle(THREAD, JNIHandles::resolve(module));
 // Obtain java.base's module version
 if (module_location != NULL) {
 location_symbol = SymbolTable::new_symbol(module_location, CHECK);
 }
 }
-objArrayOop packages_oop = objArrayOop(JNIHandles::resolve(packages));
-objArrayHandle packages_h(THREAD, packages_oop);
-int num_packages = (packages_h == NULL ? 0 : packages_h->length());
 // Check that the list of packages has no duplicates and that the
 // packages are syntactically ok.
 GrowableArray<Symbol*>* pkg_list = new GrowableArray<Symbol*>(num_packages);
 for (int x = 0; x < num_packages; x++) {
-oop string_obj = packages_h->obj_at(x);
+const char *package_name = packages[x];
-if (string_obj == NULL || !string_obj->is_a(SystemDictionary::String_klass())) {
-THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
-"Bad package name for module: " JAVA_BASE_NAME);
-}
-char *package_name = java_lang_String::as_utf8_string(string_obj);
 if (!Modules::verify_package_name(package_name)) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 err_msg("Invalid package name: %s for module: " JAVA_BASE_NAME, package_name));
 }
 Symbol* pkg_symbol = SymbolTable::new_symbol(package_name, CHECK);
 package_name, module_name));
 }
 }
 void Modules::define_module(jobject module, jstring version,
-jstring location, jobjectArray packages, TRAPS) {
+jstring location, const char* const* packages,
+jsize num_packages, TRAPS) {
 ResourceMark rm(THREAD);
 if (module == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
 }
+if (num_packages < 0) {
+THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
+"num_packages must be >= 0");
+}
+if (packages == NULL && num_packages > 0) {
+THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
+"num_packages should be zero if packages is null");
+}
 Handle module_handle(THREAD, JNIHandles::resolve(module));
 if (!java_lang_reflect_Module::is_instance(module_handle())) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "module is not an instance of type java.lang.reflect.Module");
 }
 "Module name cannot be null");
 }
 // Special handling of java.base definition
 if (strcmp(module_name, JAVA_BASE_NAME) == 0) {
-define_javabase_module(module, version, location, packages, CHECK);
+define_javabase_module(module, version, location, packages, num_packages, CHECK);
 return;
 }
 const char* module_version = get_module_version(version);
 if (loader != java_lang_ClassLoader::non_reflection_class_loader(loader)) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "Class loader is an invalid delegating class loader");
 }
 Handle h_loader = Handle(THREAD, loader);
-objArrayOop packages_oop = objArrayOop(JNIHandles::resolve(packages));
-objArrayHandle packages_h(THREAD, packages_oop);
-int num_packages = (packages_h == NULL ? 0 : packages_h->length());
 // Check that the list of packages has no duplicates and that the
 // packages are syntactically ok.
 GrowableArray<Symbol*>* pkg_list = new GrowableArray<Symbol*>(num_packages);
 for (int x = 0; x < num_packages; x++) {
-oop string_obj = packages_h->obj_at(x);
+const char* package_name = packages[x];
-if (string_obj == NULL || !string_obj->is_a(SystemDictionary::String_klass())) {
-THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
-err_msg("Bad package name for module: %s", module_name));
-}
-char *package_name = java_lang_String::as_utf8_string(string_obj);
 if (!verify_package_name(package_name)) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 err_msg("Invalid package name: %s for module: %s",
 package_name, module_name));
 }
 // Only modules defined to either the boot or platform class loader, can define a "java/" package.
 if (!h_loader.is_null() &&
 !SystemDictionary::is_platform_class_loader(h_loader) &&
 strncmp(package_name, JAVAPKG, JAVAPKG_LEN) == 0) {
 const char* class_loader_name = SystemDictionary::loader_name(h_loader());
-StringUtils::replace_no_expand(package_name, "/", ".");
+size_t pkg_len = strlen(package_name);
+char* pkg_name = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, pkg_len);
+strncpy(pkg_name, package_name, pkg_len);
+StringUtils::replace_no_expand(pkg_name, "/", ".");
 const char* msg_text1 = "Class loader (instance of): ";
 const char* msg_text2 = " tried to define prohibited package name: ";
-size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(package_name) + 1;
+size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + pkg_len + 1;
 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
-jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, package_name);
+jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, pkg_name);
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), message);
 }
 Symbol* pkg_symbol = SymbolTable::new_symbol(package_name, CHECK);
 // append_if_missing() returns FALSE if entry already exists.
 unnamed_module->set_module(ClassLoaderData::the_null_class_loader_data()->add_handle(module_handle));
 // Store pointer to the ModuleEntry in the unnamed module's java.lang.reflect.Module object.
 java_lang_reflect_Module::set_module_entry(module_handle(), unnamed_module);
 }
-void Modules::add_module_exports(jobject from_module, jstring package, jobject to_module, TRAPS) {
+void Modules::add_module_exports(jobject from_module, const char* package_name, jobject to_module, TRAPS) {
-if (package == NULL) {
+if (package_name == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
 "package is null");
 }
 if (from_module == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "to_module is invalid");
 }
 }
-PackageEntry *package_entry = get_package_entry(from_module_entry, package, CHECK);
+PackageEntry *package_entry = get_package_entry(from_module_entry, package_name, CHECK);
 ResourceMark rm(THREAD);
 if (package_entry == NULL) {
-const char *package_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(package));
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 err_msg("Package %s not found in from_module %s",
 package_name != NULL ? package_name : "",
 from_module_entry->name()->as_C_string()));
 }
 package_entry->set_exported(to_module_entry);
 }
 }
-void Modules::add_module_exports_qualified(jobject from_module, jstring package,
+void Modules::add_module_exports_qualified(jobject from_module, const char* package,
 jobject to_module, TRAPS) {
 if (to_module == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
 "to_module is null");
 }
 return JNIHandles::make_local(THREAD, module);
 }
-jobject Modules::get_module_by_package_name(jobject loader, jstring package, TRAPS) {
+jobject Modules::get_module_by_package_name(jobject loader, const char* package_name, TRAPS) {
 ResourceMark rm(THREAD);
 assert(ModuleEntryTable::javabase_defined(),
 "Attempt to call get_module_from_pkg before " JAVA_BASE_NAME " is defined");
-if (NULL == package) {
+if (package_name == NULL) {
 THROW_MSG_(vmSymbols::java_lang_NullPointerException(),
 "package is null", JNI_FALSE);
-}
-const char* package_str =
-java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(package));
-if (NULL == package_str) {
-THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
-"Invalid package", JNI_FALSE);
 }
 Handle h_loader (THREAD, JNIHandles::resolve(loader));
 // Check that loader is a subclass of java.lang.ClassLoader.
 if (loader != NULL && !java_lang_ClassLoader::is_subclass(h_loader->klass())) {
 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
 "Class loader is not a subclass of java.lang.ClassLoader", JNI_FALSE);
 }
-if (strlen(package_str) == 0) {
+if (strlen(package_name) == 0) {
 // Return the unnamed module
 ModuleEntryTable* module_table = get_module_entry_table(h_loader, CHECK_NULL);
 if (NULL == module_table) return NULL;
 const ModuleEntry* const unnamed_module = module_table->unnamed_module();
 return JNIHandles::make_local(THREAD, JNIHandles::resolve(unnamed_module->module()));
 } else {
-TempNewSymbol package_sym = SymbolTable::new_symbol(package_str, CHECK_NULL);
+TempNewSymbol package_sym = SymbolTable::new_symbol(package_name, CHECK_NULL);
 return get_module(package_sym, h_loader, CHECK_NULL);
 }
 return NULL;
 }
-jobject Modules::get_named_module(Handle h_loader, const char* package_str, TRAPS) {
+jobject Modules::get_named_module(Handle h_loader, const char* package_name, TRAPS) {
 assert(ModuleEntryTable::javabase_defined(),
 "Attempt to call get_named_module before " JAVA_BASE_NAME " is defined");
 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
 "Class loader is not a subclass of java.lang.ClassLoader");
-assert(package_str != NULL, "the package_str should not be NULL");
+assert(package_name != NULL, "the package_name should not be NULL");
-if (strlen(package_str) == 0) {
+if (strlen(package_name) == 0) {
 return NULL;
 }
-TempNewSymbol package_sym = SymbolTable::new_symbol(package_str, CHECK_NULL);
+TempNewSymbol package_sym = SymbolTable::new_symbol(package_name, CHECK_NULL);
 const PackageEntry* const pkg_entry =
 get_package_entry_by_name(package_sym, h_loader, THREAD);
 const ModuleEntry* const module_entry = (pkg_entry != NULL ? pkg_entry->module() : NULL);
 if (module_entry != NULL && module_entry->module() != NULL && module_entry->is_named()) {
 }
 return NULL;
 }
-void Modules::add_module_package(jobject module, jstring package, TRAPS) {
+void Modules::add_module_package(jobject module, const char* package_name, TRAPS) {
 ResourceMark rm(THREAD);
 if (module == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
 "module is null");
 }
-if (package == NULL) {
+if (package_name == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
 "package is null");
 }
 ModuleEntry* module_entry = get_module_entry(module, CHECK);
 if (module_entry == NULL) {
 "module is invalid");
 }
 if (!module_entry->is_named()) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "module cannot be an unnamed module");
-}
-char *package_name = java_lang_String::as_utf8_string(
-JNIHandles::resolve_non_null(package));
-if (package_name == NULL) {
-THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Bad package");
 }
 if (!verify_package_name(package_name)) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 err_msg("Invalid package name: %s", package_name));
 }
 // Only modules defined to either the boot or platform class loader, can define a "java/" package.
 if (!loader_data->is_the_null_class_loader_data() &&
 !loader_data->is_platform_class_loader_data() &&
 strncmp(package_name, JAVAPKG, JAVAPKG_LEN) == 0) {
 const char* class_loader_name = SystemDictionary::loader_name(loader_data);
-StringUtils::replace_no_expand(package_name, "/", ".");
+size_t pkg_len = strlen(package_name);
+char* pkg_name = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, pkg_len);
+strncpy(pkg_name, package_name, pkg_len);
+StringUtils::replace_no_expand(pkg_name, "/", ".");
 const char* msg_text1 = "Class loader (instance of): ";
 const char* msg_text2 = " tried to define prohibited package name: ";
-size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(package_name) + 1;
+size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + pkg_len + 1;
 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
-jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, package_name);
+jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, pkg_name);
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), message);
 }
 log_debug(modules)("add_module_package(): Adding package %s to module %s",
 package_name, module_entry->name()->as_C_string());
 throw_dup_pkg_exception(module_entry->name()->as_C_string(), existing_pkg, CHECK);
 }
 }
 // Export package in module to all unnamed modules.
-void Modules::add_module_exports_to_all_unnamed(jobject module, jstring package, TRAPS) {
+void Modules::add_module_exports_to_all_unnamed(jobject module, const char* package_name, TRAPS) {
 if (module == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
 "module is null");
 }
-if (package == NULL) {
+if (package_name == NULL) {
 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
 "package is null");
 }
 ModuleEntry* module_entry = get_module_entry(module, CHECK);
 if (module_entry == NULL) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "module is invalid");
 }
 if (module_entry->is_named()) { // No-op for unnamed module.
-PackageEntry *package_entry = get_package_entry(module_entry, package, CHECK);
+PackageEntry *package_entry = get_package_entry(module_entry, package_name, CHECK);
 ResourceMark rm(THREAD);
 if (package_entry == NULL) {
-const char *package_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(package));
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 err_msg("Package %s not found in module %s",
 package_name != NULL ? package_name : "",
 module_entry->name()->as_C_string()));
 }

changeset 43466	add500644443
parent 43446	4f9ac7ab99d9
child 43471	bfb383279a16