230 // module - pre-checked for NULL

   231 // to_module - pre-checked for NULL

   232 jvmtiError

   233 JvmtiEnv::AddModuleReads(jobject module, jobject to_module) {

   234   JavaThread* THREAD = JavaThread::current();

   235 

   236   // check module

   237   Handle h_module(THREAD, JNIHandles::resolve(module));

   238   if (!java_lang_reflect_Module::is_instance(h_module())) {

   239     return JVMTI_ERROR_INVALID_MODULE;

   240   }

   241   // check to_module

   242   Handle h_to_module(THREAD, JNIHandles::resolve(to_module));

   243   if (!java_lang_reflect_Module::is_instance(h_to_module())) {

   244     return JVMTI_ERROR_INVALID_MODULE;

   245   }

   246   return JvmtiExport::add_module_reads(h_module, h_to_module, THREAD);

   247 } /* end AddModuleReads */

   248 

   249 

   250 // module - pre-checked for NULL

   251 // pkg_name - pre-checked for NULL

   252 // to_module - pre-checked for NULL

   253 jvmtiError

   254 JvmtiEnv::AddModuleExports(jobject module, const char* pkg_name, jobject to_module) {

   255   JavaThread* THREAD = JavaThread::current();

   256   Handle h_pkg = java_lang_String::create_from_str(pkg_name, THREAD);

   257 

   258   // check module

   259   Handle h_module(THREAD, JNIHandles::resolve(module));

   260   if (!java_lang_reflect_Module::is_instance(h_module())) {

   261     return JVMTI_ERROR_INVALID_MODULE;

   262   }

   263   // check to_module

   264   Handle h_to_module(THREAD, JNIHandles::resolve(to_module));

   265   if (!java_lang_reflect_Module::is_instance(h_to_module())) {

   266     return JVMTI_ERROR_INVALID_MODULE;

   267   }

   268   return JvmtiExport::add_module_exports(h_module, h_pkg, h_to_module, THREAD);

   269 } /* end AddModuleExports */

   270 

   271 

   272 // module - pre-checked for NULL

   273 // pkg_name - pre-checked for NULL

   274 // to_module - pre-checked for NULL

   275 jvmtiError

   276 JvmtiEnv::AddModuleOpens(jobject module, const char* pkg_name, jobject to_module) {

   277   JavaThread* THREAD = JavaThread::current();

   278   Handle h_pkg = java_lang_String::create_from_str(pkg_name, THREAD);

   279 

   280   // check module

   281   Handle h_module(THREAD, JNIHandles::resolve(module));

   282   if (!java_lang_reflect_Module::is_instance(h_module())) {

   283     return JVMTI_ERROR_INVALID_MODULE;

   284   }

   285   // check to_module

   286   Handle h_to_module(THREAD, JNIHandles::resolve(to_module));

   287   if (!java_lang_reflect_Module::is_instance(h_to_module())) {

   288     return JVMTI_ERROR_INVALID_MODULE;

   289   }

   290   return JvmtiExport::add_module_opens(h_module, h_pkg, h_to_module, THREAD);

   291 } /* end AddModuleOpens */

   292 

   293 

   294 // module - pre-checked for NULL

   295 // service - pre-checked for NULL

   296 jvmtiError

   297 JvmtiEnv::AddModuleUses(jobject module, jclass service) {

   298   JavaThread* THREAD = JavaThread::current();

   299 

   300   // check module

   301   Handle h_module(THREAD, JNIHandles::resolve(module));

   302   if (!java_lang_reflect_Module::is_instance(h_module())) {

   303     return JVMTI_ERROR_INVALID_MODULE;

   304   }

   305   // check service

   306   Handle h_service(THREAD, JNIHandles::resolve_external_guard(service));

   307   if (!java_lang_Class::is_instance(h_service()) ||

   308       java_lang_Class::is_primitive(h_service())) {

   309     return JVMTI_ERROR_INVALID_CLASS;

   310   }

   311   return JvmtiExport::add_module_uses(h_module, h_service, THREAD);

   312 } /* end AddModuleUses */

   313 

   314 

   315 // module - pre-checked for NULL

   316 // service - pre-checked for NULL

   317 // impl_class - pre-checked for NULL

   318 jvmtiError

   319 JvmtiEnv::AddModuleProvides(jobject module, jclass service, jclass impl_class) {

   320   JavaThread* THREAD = JavaThread::current();

   321 

   322   // check module

   323   Handle h_module(THREAD, JNIHandles::resolve(module));

   324   if (!java_lang_reflect_Module::is_instance(h_module())) {

   325     return JVMTI_ERROR_INVALID_MODULE;

   326   }

   327   // check service

   328   Handle h_service(THREAD, JNIHandles::resolve_external_guard(service));

   329   if (!java_lang_Class::is_instance(h_service()) ||

   330       java_lang_Class::is_primitive(h_service())) {

   331     return JVMTI_ERROR_INVALID_CLASS;

   332   }

   333   // check impl_class

   334   Handle h_impl_class(THREAD, JNIHandles::resolve_external_guard(impl_class));

   335   if (!java_lang_Class::is_instance(h_impl_class()) ||

   336       java_lang_Class::is_primitive(h_impl_class())) {

   337     return JVMTI_ERROR_INVALID_CLASS;

   338   }

   339   return JvmtiExport::add_module_provides(h_module, h_service, h_impl_class, THREAD);

   340 } /* end AddModuleProvides */

   341 

   342